home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d13 / pproject.arc / NODE.CLS < prev    next >
Encoding:
Text File  |  1990-06-07  |  5.6 KB  |  228 lines
  1. /* Node is a formal class for things that are connected as part
  2.    of a Network.  Node defines the connection protocol. Nodes
  3.    know their inputs and outputs, their network and their
  4.    relative display position in the network. */!!
  5.  
  6. inherit(Object, #Node, #(name     /* node name */
  7. desc     /* longer description */
  8. inputs   /* collection of inputs */
  9. outputs  /* collection of outputs */
  10. network  /* who "owns" the node */
  11. x        /* display x position */
  12. y        /* display y position */), 2, nil)!!
  13.  
  14. now(NodeClass)!!
  15.  
  16. /* Create and initialize a new node. */
  17. Def  new(self)
  18. { 
  19.   ^init(new(self:Behavior));
  20. } !! 
  21.  
  22. now(Node)!!
  23.  
  24. /* Return the network the node belongs to. */
  25. Def  getNetwork(self)
  26. {
  27.   ^network;
  28. }!!
  29.  
  30. /* Return a point of the x and y instance variables. */
  31. Def  pos(self)
  32. {
  33.   ^point(x, y);
  34. }!!
  35.  
  36. /* Get the description. */
  37. Def  getDesc(self)
  38. { ^desc;
  39. }   !!
  40.  
  41. /* Get the x position. */
  42. Def  x(self)
  43. { ^x;
  44. }   !!
  45.  
  46. /* Get the y position. */
  47. Def  y(self)
  48. { ^y;
  49. }   !!
  50.  
  51. /* Reset the position when disconnecting.
  52.       x : the maximum level of any inputs + 1
  53.       y : don't change it since it's already set
  54.    If the x position changes, propogate it.
  55.    Tell the network also.
  56. */
  57. Def  resetPosn(self, inputNode | oldPos)
  58. {  
  59.   oldPos := pos(self);
  60.   if x <= x(inputNode) + 1
  61.     x := 0;
  62.     do(inputs,
  63.       {using(input) x := max(x(input)+1, x);
  64.     });
  65.     do(outputs,
  66.       {using(output) 
  67.        if inputNode <> output cand self <> output  /* avoid loop */
  68.          resetPosn(output, self);
  69.        endif;
  70.     });
  71.   endif;
  72.   if x+y = 0    /* completely disconnected */
  73.      y := 1;    /* use a "safe" location */
  74.   endif;
  75.   /* the new position could conflict with something else in the project */
  76.   if oldPos <> pos(self)
  77.     resetPosn(network, self, oldPos);
  78.   endif;
  79. }!!
  80.  
  81. /* Set the position when connecting.
  82.       x : the maximum level of any inputs + 1
  83.       y : the y of input plus the output number
  84.    If the x position changes, propogate it.
  85.    Also, tell the network.
  86.  */
  87. Def  setPosn(self, inputNode | oldPos)
  88. { 
  89.   oldPos := pos(self);
  90.   
  91.   /* If the node position has not been set, set it's y. */
  92.   if x = 0
  93.     y := max(0,y(inputNode) + size(getOutputs(inputNode)) - 1);
  94.   endif;
  95.   
  96.   /* If the level increases, set it and propogate. */
  97.   if x(inputNode) + 1 > x
  98.     x := x(inputNode) + 1;
  99.     do(outputs,
  100.       {using(output)    
  101.        if inputNode <> output cand self <> output  /* avoid loop */
  102.           setPosn(output, self);
  103.        endif;
  104.     });
  105.   endif;
  106.   /* the new position could conflict with something else in the project */
  107.   if oldPos <> pos(self)
  108.     resetPosn(network, self, oldPos);
  109.   endif;
  110. }!!
  111.  
  112. /* Set the network the node belongs to. */
  113. Def  setNetwork(self, aNet)
  114. {
  115.   network := aNet;
  116. }!! 
  117.  
  118. /* To disconnect node n1->n2, n1's outputs must remove n2. */
  119. Def  removeOutputs(self, aNode)
  120. { remove(outputs, aNode);
  121. }  !! 
  122.  
  123. /* To disconnect node n1->n2, n2's inputs must remove n1. */
  124. Def  removeInputs(self, aNode)
  125. { remove(inputs, aNode);
  126. }  !!
  127.  
  128. /* Disconnect n1->n2 by updating n1's outputs and n2's inputs. 
  129.    The node n2 position must be reset based on its former input. */
  130. Def  disconnect(self, aNode)
  131. { removeInputs(aNode, self);
  132.   removeOutputs(self, aNode);
  133.   resetPosn(aNode, self);
  134. } !!
  135.  
  136. /* Recursively show all outputs, level by level.
  137.    Keep track of visited nodes to avoid looping. 
  138.    n is the level for formatting.  CurPos is a
  139.    global of current print position for formatting.
  140.    Note: This is for testing networks during development.
  141. */
  142. Def  show(self, visited, n)
  143. { 
  144.   do(n-CurPos,                      /* adjust position */
  145.     {using(i) print("      ");
  146.   });
  147.   CurPos:=n;                        /* update position */
  148.   print(self);                      /* show node */
  149.   if size(outputs) == 0 then
  150.      printLine("");print("   ");
  151.      CurPos := 0;
  152.   else
  153.      CurPos := CurPos +1;
  154.   endif;
  155.   do(outputs,                       /* show outputs */
  156.     {using(elem) 
  157.       if(not(elem in visited))      /* not yet shown */
  158.         add(visited, elem);         /* avoid looping */ 
  159.         show(elem, visited, n+1);   /* recurse */
  160.       else
  161.         printLine("");
  162.         print("   ");
  163.         CurPos := 0;                /* reset position */
  164.       endif;
  165.     });
  166. } !!
  167.  
  168. /* pass through method to return a node's outputs */
  169. Def  getOutputs(self)
  170. { ^outputs;
  171. } !! 
  172.  
  173. /* pass through method to return a node's inputs */
  174. Def  getInputs(self)
  175. { ^inputs;
  176. } !!
  177.  
  178. /* To connect node n1->n2, n1's outputs must contain n2. */
  179. Def  addOutputs(self, aNode)
  180. { 
  181.   add(outputs, aNode);
  182. } !!
  183.  
  184. /* To connect n1->n2, n2's inputs must contain n1. */
  185. Def  addInputs(self, aNode)
  186. { 
  187.   add(inputs, aNode);
  188. } !!
  189.  
  190. /* Connect self->aNode by updating self's outputs and 
  191.    aNode's inputs. Also, aNode should know it's network
  192.    and the position should be set based on it's input. */
  193. Def  connect(self, aNode)
  194. { addInputs(aNode, self);
  195.   addOutputs(self, aNode);
  196.   setNetwork(aNode, network);
  197.   setPosn(aNode, self);
  198. } !!
  199.  
  200. /* Set the name. */
  201. Def  setName(self, aName)
  202. { name := aName;
  203. }   !!
  204.  
  205. /* Get the name. */
  206. Def  getName(self)
  207. { ^name;
  208. }   !!
  209.  
  210. /* Initialize a new node.  Set the name, desc
  211.    and position to safe values.  Keep track of
  212.    our connections in inputs and outputs.  These
  213.    sets will grow as necessary. */
  214. Def  init(self)
  215. { name := desc:= "";
  216.   x := y := 0;
  217.   inputs := new(Set, 2);
  218.   outputs := new(Set, 2);
  219. }  !!
  220.  
  221. /* Print the node.  
  222.    This is used during development only. */
  223. Def  printOn(self, aStrm)
  224. { 
  225.   printOn(asString(class(self))+":"+asString(name), aStrm);
  226. }!! 
  227.  
  228.